package controllers

import (
	"database/sql"
	"net/http"
	"strconv"

	"web-service/models"

	"github.com/gin-gonic/gin"
)

type AuthorController struct {
	DB *sql.DB
}

// SearchAuthor 搜索作者
func (c *AuthorController) SearchAuthor(ctx *gin.Context) {
	// 获取搜索关键词
	keyword := ctx.Query("keyword")
	if keyword == "" {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "搜索关键词不能为空",
		})
		return
	}

	// 搜索作者
	authors, err := models.SearchAuthor(c.DB, keyword)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": "搜索作者失败",
			"error":   err.Error(),
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": authors,
	})
}

// GetAuthorList 获取作者列表
func (c *AuthorController) GetAuthorList(ctx *gin.Context) {
	// 获取分页参数
	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("pageSize", "10"))

	// 获取作者列表
	authors, total, err := models.GetAuthorList(c.DB, page, pageSize)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": "获取作者列表失败",
			"error":   err.Error(),
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code": 200,
		"data": gin.H{
			"list":  authors,
			"total": total,
		},
	})
}

// CreateAuthor 创建作者
func (c *AuthorController) CreateAuthor(ctx *gin.Context) {
	// 获取请求参数
	var req struct {
		Name string `json:"name" binding:"required"`
	}

	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "请求参数错误",
			"error":   err.Error(),
		})
		return
	}

	// 创建作者
	err := models.CreateAuthor(c.DB, req.Name)
	if err != nil {
		if err == models.ErrAuthorExists {
			ctx.JSON(http.StatusBadRequest, gin.H{
				"code":    400,
				"message": "作者名称已存在",
			})
			return
		}
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": "创建作者失败",
			"error":   err.Error(),
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "创建成功",
	})
}

// UpdateAuthor 更新作者信息
func (c *AuthorController) UpdateAuthor(ctx *gin.Context) {
	// 获取作者ID
	id, err := strconv.ParseInt(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "无效的作者ID",
			"error":   err.Error(),
		})
		return
	}

	// 获取请求参数
	var req struct {
		Name string `json:"name" binding:"required"`
	}

	if err := ctx.ShouldBindJSON(&req); err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "请求参数错误",
			"error":   err.Error(),
		})
		return
	}

	// 更新作者
	err = models.UpdateAuthor(c.DB, id, req.Name)
	if err != nil {
		if err == models.ErrAuthorExists {
			ctx.JSON(http.StatusBadRequest, gin.H{
				"code":    400,
				"message": "作者名称已存在",
			})
			return
		}
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": "更新作者失败",
			"error":   err.Error(),
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "更新成功",
	})
}

// DeleteAuthor 删除作者
func (c *AuthorController) DeleteAuthor(ctx *gin.Context) {
	// 获取作者ID
	id, err := strconv.ParseInt(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "无效的作者ID",
			"error":   err.Error(),
		})
		return
	}

	// 删除作者
	err = models.DeleteAuthor(c.DB, id)
	if err != nil {
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": "删除作者失败",
			"error":   err.Error(),
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "删除成功",
	})
}
